import React, { useState, useEffect } from 'react';
import { Form } from 'antd';
import type { FormInstance } from 'antd';
import type { ResultItem } from '../../../shared/types';
import CalculationCard from './CalculationCard';
import { getFormInitialValues, saveFormDefaultValues, resetFormToDefault, getFormDefaultValues, saveFormInitialValues } from '../utils/formStorage';
import { saveHistoryItem } from '../utils/calculationHistory';
import useIpcCalculation from '../../features/calculator/hooks/useIpcCalculation';
import notificationService from '../../services/notificationService';
import errorHandlerService from '../../services/errorHandlerService';

/**
 * 有状态的计算卡片组件属性接口
 * 定义了有状态计算卡片组件所需的所有属性
 */
interface StatefulCalculationCardProps {
  /** 计算卡片标题 */
  title: string;
  /** 表单键，用于标识和存储表单数据 */
  formKey: string;
  /** 表单初始值 */
  initialValues: any;
  /** 渲染表单字段的函数 */
  renderFormFields: () => React.ReactNode;
  /** 计算类型，可以是字符串或根据表单值动态确定的函数 */
  calculationType: string | ((values: any) => string);
  /** 结果格式化函数，将计算结果转换为表格显示格式 */
  resultFormatter: (data: any) => ResultItem[];
  /** 表单布局列数，控制输入字段的排列方式，默认为1 */
  columnCount?: number;
  /** 表格高度，默认为400px */
  tableHeight?: number;
  /** LaTeX公式字符串，将通过统一的renderLatex函数渲染 */
  formula?: string;
  /** 可选回调：在重置表单到默认值后调用，参数为默认值对象 */
  onAfterReset?: (defaultValues: any) => void;
  /** 导出组件 */
  exportComponent?: (form: FormInstance) => React.ReactNode;
}

/**
 * 有状态的计算卡片组件
 * 
 * 该组件是计算功能的核心组件，封装了完整的计算流程，包括：
 * 1. 表单状态管理
 * 2. 表单数据持久化
 * 3. IPC计算调用
 * 4. 计算结果处理和格式化
 * 5. 计算历史记录保存
 * 6. 错误处理
 * 
 * 组件特性：
 * - 自动保存和恢复表单数据
 * - 支持动态计算类型选择
 * - 集成计算历史记录功能
 * - 统一的错误处理机制
 * - 支持自定义结果格式化
 * - 支持数学公式显示
 * 
 * 该组件基于无状态的CalculationCard组件构建，添加了状态管理和业务逻辑
 */
const StatefulCalculationCard: React.FC<StatefulCalculationCardProps> = ({
  title,
  formKey,
  initialValues,
  renderFormFields,
  calculationType,
  resultFormatter,
  columnCount = 1, // 默认1列
  tableHeight = 400, // 默认高度400px
  formula // 公式内容
  ,
  onAfterReset,
  exportComponent
}) => {
  // Use a ref to receive the form instance from CalculationCard
  const formRef = React.useRef<FormInstance<any> | null>(null);
  const [result, setResult] = useState<ResultItem[]>([]);
  const [isCalculating, setIsCalculating] = useState<boolean>(false);
  const [form] = Form.useForm();
  const { runCalculation } = useIpcCalculation();
  
  /**
   * 保存计算历史记录
   * 
   * 将计算参数和结果保存到本地存储的历史记录中
   * 可通过应用设置控制是否启用历史记录功能
   * 
   * @param params 计算参数
   * @param results 计算结果
   */
  const saveToHistory = (params: any, results: ResultItem[]) => {
    try {
      const settingsRaw = localStorage.getItem('appSettings');
      const settings = settingsRaw ? JSON.parse(settingsRaw) : { enableHistory: true, historyMaxCount: 20 };
      if (!settings.enableHistory) return;

      // 确定实际使用的计算类型
      const actualCalculationType = typeof calculationType === 'function' 
        ? calculationType(params) 
        : calculationType;

      const historyItem = {
        id: `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
        title,
        calculationType: actualCalculationType,
        params: { ...params },
        results: results ? [...results] : [],
        timestamp: Date.now()
      };

      saveHistoryItem(historyItem);
    } catch (err) {
      console.error('saveToHistory failed', err);
    }
  };
  
  // 定义结果表格列
  const columns = [
    { title: '项目', dataIndex: 'name', key: 'name' },
    { title: '数值', dataIndex: 'value', key: 'value' },
    { title: '单位', dataIndex: 'unit', key: 'unit' }
  ];
  
  // 根据columnCount参数优化表单布局，确保充分利用可用空间

  // 初始化表单值
  useEffect(() => {
    try {
      const lastParams = getFormInitialValues(formKey) || initialValues;
      // if formRef is ready, set values; otherwise they'll be set when form is created
      if (formRef.current) {
        formRef.current.setFieldsValue(lastParams);
      }
      saveFormDefaultValues(formKey, initialValues);
    } catch (err) {
      console.error('表单初始化异常', err);
    }
  }, [formRef, formKey, initialValues]);

  /**
   * 处理表单值变化事件
   * 
   * 当表单值发生变化时，自动保存到localStorage
   * 确保在页面切换或应用重启后能够恢复参数
   */
  const handleValuesChange = (changedValues: any, allValues: any) => {
    try {
      // 保存表单值到localStorage
      saveFormInitialValues(formKey, allValues);
    } catch (err) {
      console.error('保存表单值失败:', err);
    }
  };

  /**
   * 处理计算按钮点击事件
   * 
   * 执行完整的计算流程：
   * 1. 表单验证
   * 2. 获取表单值
   * 3. 确定计算类型
   * 4. 调用IPC计算服务
   * 5. 格式化结果
   * 6. 保存历史记录
   */
  const handleCalculate = async () => {
    try {
      setIsCalculating(true);
      // 验证表单
      await form.validateFields();
      
      // 获取表单值
      const formValues = form.getFieldsValue();
      
      console.log('表单值:', formValues);
      
      // 确定实际使用的计算类型
      const actualCalculationType = typeof calculationType === 'function' 
        ? calculationType(formValues) 
        : calculationType;
      
      // 检查计算类型是否有效
      if (!actualCalculationType || actualCalculationType.trim() === '') {
        notificationService.error('无法确定有效的计算类型，请检查输入参数');
        setIsCalculating(false);
        return;
      }
      
      // 调用 IPC 计算服务
      const apiRes = await runCalculation(actualCalculationType, formValues);
      
      console.log('计算结果:', apiRes);
      
      if (!apiRes.success) throw new Error('calculate-failed');
      
      // 创建一个新的formatter函数，将表单值与后端返回的数据合并
      const enhancedFormatter = (data: any) => {
        // 将表单值与后端返回的数据合并，确保表单值（如渣场名称）可以在resultFormatter中访问
        const mergedData = { ...data, ...formValues };
        return resultFormatter(mergedData);
      };
      
      // 格式化结果
      const formattedResult = enhancedFormatter(apiRes.results);
      setResult(formattedResult);
      
      // 保存到历史记录
      saveToHistory(formValues, formattedResult);
    } catch (err: any) {
      console.error('计算错误:', err);
      const errorInstance = err instanceof Error ? err : new Error(String(err));
      errorHandlerService.handleCalculationError(
        errorInstance,
        '计算过程中发生错误'
      );
    } finally {
      setIsCalculating(false);
    }
  };

  /**
   * 处理重置按钮点击事件
   * 
   * 重置表单到默认值并清空计算结果
   */
  const handleReset = () => {
    if (formRef.current) {
      formRef.current.resetFields();
      form.resetFields();
      resetFormToDefault(formRef.current, formKey);
    } else {
      // fallback: still reset saved defaults
      resetFormToDefault(undefined as any, formKey);
    }
    // 获取默认值并通知调用方（例如让上层组件同步本地 state）
    try {
      const defaults = getFormDefaultValues(formKey) || {};
      if (typeof onAfterReset === 'function') {
        onAfterReset(defaults);
      }
    } catch (e) {
      // ignore
    }
    setResult([]);
    notificationService.success('已重置到默认参数');
  };


  return (
    <CalculationCard
      title={title}
      form={form}
      formRef={formRef}
      initialValues={initialValues}
      renderFormFields={renderFormFields}
      result={result}
      onCalculate={handleCalculate}
      onReset={handleReset}
      columns={columns}
      columnCount={columnCount}
      tableHeight={tableHeight}
      formula={formula}
      isCalculating={isCalculating}
      exportComponent={exportComponent ? exportComponent(form) : undefined}
      onValuesChange={handleValuesChange}
    />
  );
};

export default StatefulCalculationCard;